pub  fn owner_test(){
    /*
    1.rust 中 每一个值都有一个所有者 （owner）、
    2.值再任一时刻有且只有一个所有者
    3.当所有者（变量）离开作用域时，这个作用域的值就会被回收（丢弃）
    
     */
    //这是一个作用域
    {
     
    
     let st=String ::from("54321");
     println!("{}",st);
    
     //所有权转移
     let stt=st;
    
     //此段代码会编译失败，因为在此之前 st 指向的内存的所有者变成了 stt
     //println!("{}",st);// value borrowed here after move
     println!("st 所有权转移到 stt,输出stt-{}",stt);
    
     //值得注意的是，在内存中 如果一开始就确定内存大小的数据类型 所有权转移后仍然可以使用 如 u32,u16,bool (u32,boo)确定内容的元组等
     let x =5;
     let xx =x;
     println!("x-{x}");
     println!("xx-{x}");
    
     let tup: (i32, i32, bool, f64) =(12,34,false,2.9);
     let tupp=tup;
     println!("tup-{0},{1},{2},{3}",tup.0,tup.1,tup.2,tup.3);
     println!("tupp-{0},{1},{2},{3}",tupp.0,tupp.1,tupp.2,tupp.3);
     
     //所有权与函数的关系
     /*
       如果一个变量作为参数传入某个函数，那么这个变量的所有者就变成了 被调用函数，在这个函数之后 变量无法使用
      */
      owner_fn(tupp);
    
      //刚刚在写这段代码的时候忽略以一个问题，对于一开始就确定内存大小的 数据类型 他的所有权不会发生改变
      fn owner_fn(tupp: (i32, i32, bool, f64) ){
        println!("owner_fn-tupp-{0},{1},{2},{3}",tupp.0,tupp.1,tupp.2,tupp.3);
      }
      println!("tupp-{0},{1},{2},{3}",tupp.0,tupp.1,tupp.2,tupp.3);
    
      owner_fns(stt);
      //现在我们试一下 用 string 入参
    fn owner_fns(stt: String){
        println!("stt 所有权转移到 owner_fns,输出stt-{}",stt);
    }
    // 此段代码会编译失败，stt 所有权已转移到 owner_fns  编译器直接提示所有权转移   value borrowed here after move  
    //println!("stt 所有权转移到 owner_fns之后输出stt-{}",stt);
    
    //关于函数的所有权返回
     let owner_returns_str =owner_return();
     println!("owner_returns_str-{}",owner_returns_str);
    fn owner_return() -> String{
    
     let stt = String::from("owner_return");
        return  stt;
    }
    println!("owner_returns_str1-{}",owner_returns_str);
    
    //stt 参数重影
    let stt=String::from("我是靓仔");
    println!("{}",stt);
    //先将 stt 所有权转移
      let stt =owner_return_1(stt);
      println!("stt 所有权回归-{}",stt);
    
    fn owner_return_1(stt: String) ->String{
        println!("stt 所有权转移到 owner_return_1-{}",stt);
        return  stt;
    }
    
    
    
    }
    //此段代码离开了属于他的作用域之后，他的所有权被回收所以会编译错误
    //println!("{s}");
    //println!(st);
    }
    